/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package controlador;

import controlador.exceptions.NonexistentEntityException;
import java.io.Serializable;
import javax.persistence.Query;
import javax.persistence.EntityNotFoundException;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Root;
import entidad.Ordenentrada;
import entidad.Proveedores;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;

/**
 *
 * @author a
 */
public class ProveedoresJpaController implements Serializable {

    public ProveedoresJpaController(EntityManagerFactory emf) {
        this.emf = emf;
    }
    private EntityManagerFactory emf = null;

    public EntityManager getEntityManager() {
        return emf.createEntityManager();
    }

    public void create(Proveedores proveedores) {
        if (proveedores.getOrdenentradaCollection() == null) {
            proveedores.setOrdenentradaCollection(new ArrayList<Ordenentrada>());
        }
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            Collection<Ordenentrada> attachedOrdenentradaCollection = new ArrayList<Ordenentrada>();
            for (Ordenentrada ordenentradaCollectionOrdenentradaToAttach : proveedores.getOrdenentradaCollection()) {
                ordenentradaCollectionOrdenentradaToAttach = em.getReference(ordenentradaCollectionOrdenentradaToAttach.getClass(), ordenentradaCollectionOrdenentradaToAttach.getIdOrdenEntrada());
                attachedOrdenentradaCollection.add(ordenentradaCollectionOrdenentradaToAttach);
            }
            proveedores.setOrdenentradaCollection(attachedOrdenentradaCollection);
            em.persist(proveedores);
            for (Ordenentrada ordenentradaCollectionOrdenentrada : proveedores.getOrdenentradaCollection()) {
                Proveedores oldProveedoridProveedorOfOrdenentradaCollectionOrdenentrada = ordenentradaCollectionOrdenentrada.getProveedoridProveedor();
                ordenentradaCollectionOrdenentrada.setProveedoridProveedor(proveedores);
                ordenentradaCollectionOrdenentrada = em.merge(ordenentradaCollectionOrdenentrada);
                if (oldProveedoridProveedorOfOrdenentradaCollectionOrdenentrada != null) {
                    oldProveedoridProveedorOfOrdenentradaCollectionOrdenentrada.getOrdenentradaCollection().remove(ordenentradaCollectionOrdenentrada);
                    oldProveedoridProveedorOfOrdenentradaCollectionOrdenentrada = em.merge(oldProveedoridProveedorOfOrdenentradaCollectionOrdenentrada);
                }
            }
            em.getTransaction().commit();
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void edit(Proveedores proveedores) throws NonexistentEntityException, Exception {
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            Proveedores persistentProveedores = em.find(Proveedores.class, proveedores.getIdProveedores());
            Collection<Ordenentrada> ordenentradaCollectionOld = persistentProveedores.getOrdenentradaCollection();
            Collection<Ordenentrada> ordenentradaCollectionNew = proveedores.getOrdenentradaCollection();
            Collection<Ordenentrada> attachedOrdenentradaCollectionNew = new ArrayList<Ordenentrada>();
            for (Ordenentrada ordenentradaCollectionNewOrdenentradaToAttach : ordenentradaCollectionNew) {
                ordenentradaCollectionNewOrdenentradaToAttach = em.getReference(ordenentradaCollectionNewOrdenentradaToAttach.getClass(), ordenentradaCollectionNewOrdenentradaToAttach.getIdOrdenEntrada());
                attachedOrdenentradaCollectionNew.add(ordenentradaCollectionNewOrdenentradaToAttach);
            }
            ordenentradaCollectionNew = attachedOrdenentradaCollectionNew;
            proveedores.setOrdenentradaCollection(ordenentradaCollectionNew);
            proveedores = em.merge(proveedores);
            for (Ordenentrada ordenentradaCollectionOldOrdenentrada : ordenentradaCollectionOld) {
                if (!ordenentradaCollectionNew.contains(ordenentradaCollectionOldOrdenentrada)) {
                    ordenentradaCollectionOldOrdenentrada.setProveedoridProveedor(null);
                    ordenentradaCollectionOldOrdenentrada = em.merge(ordenentradaCollectionOldOrdenentrada);
                }
            }
            for (Ordenentrada ordenentradaCollectionNewOrdenentrada : ordenentradaCollectionNew) {
                if (!ordenentradaCollectionOld.contains(ordenentradaCollectionNewOrdenentrada)) {
                    Proveedores oldProveedoridProveedorOfOrdenentradaCollectionNewOrdenentrada = ordenentradaCollectionNewOrdenentrada.getProveedoridProveedor();
                    ordenentradaCollectionNewOrdenentrada.setProveedoridProveedor(proveedores);
                    ordenentradaCollectionNewOrdenentrada = em.merge(ordenentradaCollectionNewOrdenentrada);
                    if (oldProveedoridProveedorOfOrdenentradaCollectionNewOrdenentrada != null && !oldProveedoridProveedorOfOrdenentradaCollectionNewOrdenentrada.equals(proveedores)) {
                        oldProveedoridProveedorOfOrdenentradaCollectionNewOrdenentrada.getOrdenentradaCollection().remove(ordenentradaCollectionNewOrdenentrada);
                        oldProveedoridProveedorOfOrdenentradaCollectionNewOrdenentrada = em.merge(oldProveedoridProveedorOfOrdenentradaCollectionNewOrdenentrada);
                    }
                }
            }
            em.getTransaction().commit();
        } catch (Exception ex) {
            String msg = ex.getLocalizedMessage();
            if (msg == null || msg.length() == 0) {
                Integer id = proveedores.getIdProveedores();
                if (findProveedores(id) == null) {
                    throw new NonexistentEntityException("The proveedores with id " + id + " no longer exists.");
                }
            }
            throw ex;
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void destroy(Integer id) throws NonexistentEntityException {
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            Proveedores proveedores;
            try {
                proveedores = em.getReference(Proveedores.class, id);
                proveedores.getIdProveedores();
            } catch (EntityNotFoundException enfe) {
                throw new NonexistentEntityException("The proveedores with id " + id + " no longer exists.", enfe);
            }
            Collection<Ordenentrada> ordenentradaCollection = proveedores.getOrdenentradaCollection();
            for (Ordenentrada ordenentradaCollectionOrdenentrada : ordenentradaCollection) {
                ordenentradaCollectionOrdenentrada.setProveedoridProveedor(null);
                ordenentradaCollectionOrdenentrada = em.merge(ordenentradaCollectionOrdenentrada);
            }
            em.remove(proveedores);
            em.getTransaction().commit();
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public List<Proveedores> findProveedoresEntities() {
        return findProveedoresEntities(true, -1, -1);
    }

    public List<Proveedores> findProveedoresEntities(int maxResults, int firstResult) {
        return findProveedoresEntities(false, maxResults, firstResult);
    }

    private List<Proveedores> findProveedoresEntities(boolean all, int maxResults, int firstResult) {
        EntityManager em = getEntityManager();
        try {
            CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
            cq.select(cq.from(Proveedores.class));
            Query q = em.createQuery(cq);
            if (!all) {
                q.setMaxResults(maxResults);
                q.setFirstResult(firstResult);
            }
            return q.getResultList();
        } finally {
            em.close();
        }
    }

    public Proveedores findProveedores(Integer id) {
        EntityManager em = getEntityManager();
        try {
            return em.find(Proveedores.class, id);
        } finally {
            em.close();
        }
    }

    public int getProveedoresCount() {
        EntityManager em = getEntityManager();
        try {
            CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
            Root<Proveedores> rt = cq.from(Proveedores.class);
            cq.select(em.getCriteriaBuilder().count(rt));
            Query q = em.createQuery(cq);
            return ((Long) q.getSingleResult()).intValue();
        } finally {
            em.close();
        }
    }
    
}
